home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / oscar / OscarUtil.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  15KB  |  432 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from util.primitives import odict
  5. import struct
  6. import util
  7. import sys
  8. import array
  9. import logging
  10. import string
  11. from collections import defaultdict
  12. import oscar
  13. log = logging.getLogger('oscar.util')
  14. len_to_fmt = {
  15.     0: '',
  16.     1: 'B',
  17.     2: 'H',
  18.     4: 'I',
  19.     8: 'Q',
  20.     16: '16s' }
  21.  
  22. def lowerstrip(s):
  23.     return s.lower().replace(' ', '')
  24.  
  25.  
  26. def tflv(type_, flags = 1, data = ''):
  27.     return struct.pack('!HBB', type_, flags, len(data)) + data
  28.  
  29.  
  30. def tflv_list(*tflvs):
  31.     return ''.join((lambda .0: for t in .0:
  32. tflv(*t))(tflvs))
  33.  
  34.  
  35. def tlv(type_, length = 0, value = 0):
  36.     if isinstance(length, basestring):
  37.         value = length
  38.         length = len(value)
  39.     elif not isinstance(value, (int, long)):
  40.         raise AssertionError('%r is not an integer' % value)
  41.     
  42.     if isinstance(value, basestring):
  43.         fmt_string = None if value else ''
  44.     else:
  45.         fmt_string = len_to_fmt[length]
  46.     args = [
  47.         type_]
  48.     None += args if length else [
  49.         0]
  50.     if value:
  51.         pass
  52.     elif length:
  53.         pass
  54.     
  55.     args += []
  56.     
  57.     try:
  58.         return struct.pack('!HH' + fmt_string, *args)
  59.     except Exception:
  60.         print fmt_string, args
  61.         raise 
  62.  
  63.  
  64.  
  65. def tlv_list(*tlvs):
  66.     return ''.join((lambda .0: for t in .0:
  67. tlv(*t))(tlvs))
  68.  
  69.  
  70. def s_tlv(data, byte_order = '!'):
  71.     (t, l) = struct.unpack(byte_order + 'HH', data[:4])
  72.     data = data[4:]
  73.     v = data[:l]
  74.     data = data[l:]
  75.     return (util.Storage(t = t, l = l, v = v), data)
  76.  
  77.  
  78. def tlv_list_to_dict(tlv_list):
  79.     return odict((lambda .0: for tlv in .0:
  80. (tlv.t, tlv.v))(tlv_list))
  81.  
  82.  
  83. def s_tflv(data, byte_order = '!'):
  84.     fmt = (('type', 'H'), ('flags', 'B'), ('length', 'B'), ('value', 's', 'length'))
  85.     (t, f, l, v, data) = apply_format(fmt, data)
  86.     return (util.Storage(t = t, f = f, l = l, v = v), data)
  87.  
  88.  
  89. def list_reader(of_what, byte_order = '!'):
  90.     
  91.     def read_list(data, count = (None, -1)):
  92.         objs = []
  93.         while data and count:
  94.             (thing, data) = of_what(data, byte_order)
  95.             objs.append(thing)
  96.             
  97.             try:
  98.                 count -= 1
  99.             continue
  100.             except TypeError:
  101.                 print count
  102.                 raise 
  103.                 continue
  104.             
  105.  
  106.             None<EXCEPTION MATCH>TypeError
  107.         return (objs, data)
  108.  
  109.     return read_list
  110.  
  111. s_tflv_list = list_reader(s_tflv)
  112. s_tlv_list = list_reader(s_tlv)
  113.  
  114. def decode(s, enc):
  115.     if enc.find('; charset="') != -1:
  116.         (msgtype, encoding) = enc.split('; charset="')
  117.         encoding = encoding[:-1]
  118.     else:
  119.         log.warning('oscar.decode encountered "%s", no charset--assuming utf-8', enc)
  120.         encoding = 'utf-8'
  121.     encoding = encoding.split('\x00', 1)[0]
  122.     encodings = {
  123.         'unicode-2-0': 'utf-16be',
  124.         'utf-8': 'utf-8',
  125.         'us-ascii': 'ascii' }
  126.     encoding = encodings.get(encoding, encoding)
  127.     return util.fuzzydecode(s, encoding)
  128.  
  129. struct_types = set('xcbhilqfdsp')
  130. oscar_types = set([
  131.     'tlv',
  132.     'tlv_list',
  133.     'tlv_dict',
  134.     'named_tlvs',
  135.     'list',
  136.     'tflv',
  137.     'tflv_list',
  138.     'rate_class_list',
  139.     'rate_group_list',
  140.     'pstring',
  141.     'message_block',
  142.     'ssi_dict',
  143.     'ssi',
  144.     'tlv_list_len',
  145.     'tlv_dict_len',
  146.     'userinfo',
  147.     'dc_info',
  148.     'rate_class',
  149.     'msg_fragment',
  150.     'lnts'])
  151. all_format_types = struct_types | oscar_types
  152. digits = set(string.digits)
  153.  
  154. def apply_format(format, data, byte_order = '!'):
  155.     if not isinstance(format, (tuple, list)) and isinstance(format[0], (tuple, list)):
  156.         raise TypeError('apply_format needs a tuple of tuples')
  157.     
  158.     fields = { }
  159.     to_return = []
  160.     for item in format:
  161.         name = item[0]
  162.         kind = item[1]
  163.         args = item[2:]
  164.         skind = kind
  165.         while len(skind) > 0 and skind[0] in digits:
  166.             skind = skind[1:]
  167.         if kind.lower() in oscar_types:
  168.             f = globals().get('apply_format_%s' % kind, None)
  169.             if f is None:
  170.                 raise Exception('%r is not a valid format type' % kind)
  171.             
  172.             (fields[name], data) = f(data, fields, byte_order, *args)
  173.             to_return.append(fields[name])
  174.             continue
  175.         
  176.         prev_name = None if args else None
  177.         if prev_name is not None:
  178.             fmt = None % ('%d%s' if isinstance(prev_name, int) else fields[prev_name], kind)
  179.         else:
  180.             fmt = kind
  181.         fmt = byte_order + fmt
  182.         
  183.         try:
  184.             sz = struct.calcsize(fmt)
  185.         except Exception:
  186.             print 'BAD FORMAT:', fmt
  187.             raise 
  188.  
  189.         
  190.         try:
  191.             fields[name] = struct.unpack(fmt, data[:sz])
  192.         except Exception:
  193.             print name, fmt, util.to_hex(data)
  194.             raise 
  195.  
  196.         if len(fields[name]) == 1:
  197.             fields[name] = fields[name][0]
  198.         
  199.         data = data[sz:]
  200.         to_return.append(fields[name])
  201.     
  202.     to_return.append(data)
  203.     return to_return
  204.  
  205.  
  206. def apply_format_tlv(data, fields, byte_order):
  207.     return s_tlv(data)
  208.  
  209.  
  210. def apply_format_tlv_dict(data, fields, byte_order, num_tlvs_s = -1):
  211.     (tlvs, data) = apply_format_tlv_list(data, fields, byte_order, num_tlvs_s)
  212.     return (tlv_list_to_dict(tlvs), data)
  213.  
  214.  
  215. def apply_format_tlv_dict_len(data, fields, byte_order, byte_count_s):
  216.     (tlvs, data) = apply_format_tlv_list_len(data, fields, byte_order, byte_count_s)
  217.     return (tlv_list_to_dict(tlvs), data)
  218.  
  219.  
  220. def apply_format_tlv_list(data, fields, byte_order, num_tlvs_s = -1):
  221.     if isinstance(num_tlvs_s, basestring):
  222.         num_tlvs = fields[num_tlvs_s]
  223.     else:
  224.         num_tlvs = num_tlvs_s
  225.     return s_tlv_list(data, num_tlvs)
  226.  
  227.  
  228. def apply_format_tlv_list_len(data, fields, byte_order, byte_count_s):
  229.     if isinstance(byte_count_s, basestring):
  230.         byte_count = fields[byte_count_s]
  231.     else:
  232.         byte_count = byte_count_s
  233.     indata = data[:byte_count]
  234.     rdata = data[byte_count:]
  235.     (tlvs, outdata) = apply_format_tlv_list(indata, fields, byte_order, -1)
  236.     return (tlvs, rdata)
  237.  
  238.  
  239. def apply_format_named_tlvs(data, fields, byte_order, tlv_count_s, tlv_types):
  240.     if isinstance(tlv_count_s, basestring):
  241.         tlv_count = fields[tlv_count_s]
  242.     else:
  243.         tlv_count = tlv_count_s
  244.     (tlvs, data) = s_tlv_list(data, tlv_count)
  245.     bynumber = tlv_list_to_dict(tlvs)
  246.     named_tlvs = util.Storage()
  247.     for type, tlv in bynumber.iteritems():
  248.         named_tlvs[tlv_types.get(type, type)] = tlv
  249.     
  250.     return (named_tlvs, data)
  251.  
  252.  
  253. def apply_format_tflv(data, fields, byte_order):
  254.     return s_tflv(data)
  255.  
  256.  
  257. def apply_format_tflv_list(data, fields, byte_order, num_tflvs_s = -1):
  258.     if isinstance(num_tflvs_s, basestring):
  259.         num_tflvs = fields[num_tflvs_s]
  260.     else:
  261.         num_tflvs = num_tflvs_s
  262.     return s_tflv_list(data, num_tflvs)
  263.  
  264.  
  265. def apply_format_userinfo(data, fields, byte_order):
  266.     userinfo_types = {
  267.         1: 'user_class',
  268.         2: 'create_time',
  269.         3: 'signon_time',
  270.         4: 'idle_time',
  271.         5: 'account_creation_time',
  272.         6: 'user_status_icq',
  273.         10: 'external_ip_icq',
  274.         12: 'dc_info',
  275.         13: 'capabilities',
  276.         15: 'online_time',
  277.         29: 'avail_msg',
  278.         35: 'profile_updated',
  279.         38: 'mystery_updated',
  280.         39: 'away_updated' }
  281.     fmt = (('sn', 'pstring'), ('warning', 'H'), ('num_tlvs', 'H'), ('tlvs', 'named_tlvs', 'num_tlvs', userinfo_types))
  282.     (sn, warning, __, userdict, data) = apply_format(fmt, data)
  283.     userdict.nice_name = sn
  284.     userdict.name = sn.lower().replace(' ', '')
  285.     userdict.warning_level = warning
  286.     return (userdict, data)
  287.  
  288.  
  289. def apply_format_dc_info(data, fields, byte_order):
  290.     names = 'ip port type version cookie web_port features info_update_time '.split()
  291.     sizes = '4B I    B    H       I      I        I        I                '.split()
  292.     names += 'ext_update_time status_update_time unknown'.split()
  293.     sizes += 'I               I                  H      '.split()
  294.     stuff = apply_format(zip(names, sizes), data)
  295.     return (util.Storage(zip(names, stuff[:-1])), data[-1])
  296.  
  297.  
  298. def apply_format_list(data, fields, byte_order, kind, count_s = -1):
  299.     if isinstance(count_s, basestring):
  300.         count = fields[count_s]
  301.     else:
  302.         count = count_s
  303.     result = []
  304.     while data and count:
  305.         (info, data) = apply_format((('info', kind),), data, byte_order)
  306.         result.append(info)
  307.         count -= 1
  308.     return (result, data)
  309.  
  310.  
  311. def apply_format_rate_class(data, fields, byte_order):
  312.     fmt_str1 = 'id               H window           I clear_level      I alert_level      I limit_level      I disconnect_level I current_level    I max_level        I last_time        I state            B'.split()
  313.     rate_class_fmt = zip(fmt_str1[::2], fmt_str1[1::2])
  314.     info = apply_format(rate_class_fmt, data, byte_order)
  315.     data = info.pop()
  316.     rate_class = util.Storage(zip(fmt_str1[::2], info))
  317.     return (rate_class, data)
  318.  
  319.  
  320. def apply_format_rate_class_list(data, fields, byte_order, num_classes_s):
  321.     if isinstance(num_classes_s, basestring):
  322.         num_classes = fields[num_classes_s]
  323.     else:
  324.         num_classes = num_classes_s
  325.     classes = []
  326.     while data and num_classes:
  327.         (rate_class, data) = apply_format_rate_class(data, fields, byte_order)
  328.         classes.append(rate_class)
  329.         num_classes -= 1
  330.     return (classes, data)
  331.  
  332.  
  333. def apply_format_pstring(data, fields, byte_order):
  334.     l = struct.unpack('B', data[:1])[0]
  335.     string_ = struct.unpack(str(l) + 's', data[1:1 + l])[0]
  336.     return (string_, data[l + 1:])
  337.  
  338.  
  339. def apply_format_message_block(data, fields, byte_order):
  340.     msg = util.Storage()
  341.     fmt = (('msg_fragments', 'list', 'msg_fragment'),)
  342.     (msg_fragments, data) = apply_format(fmt, data)
  343.     msgs = _[1]
  344.     res = dict(msg_fragments)
  345.     return (res, data)
  346.  
  347.  
  348. def apply_format_msg_fragment(data, fields, byte_order):
  349.     fmt = (('type', 'B'), ('version', 'B'), ('length', 'H'), ('data', 's', 'length'))
  350.     (type, __, __, data, remaining_data) = apply_format(fmt, data, byte_order)
  351.     return ((type, data), remaining_data)
  352.  
  353.  
  354. def apply_format_rate_group(data, fields, byte_order):
  355.     _data = data[:]
  356.     rate_group_fmt = (('id', 'H'), ('num_pairs', 'H'), ('pairs_list', 'list', 'I', 'num_pairs'))
  357.     
  358.     try:
  359.         stuff = apply_format(rate_group_fmt, data, byte_order)
  360.     except ValueError:
  361.         e = None
  362.         stuff = apply_format(rate_group_fmt, _data, '<')
  363.  
  364.     (id, num_pairs, pairs_list, data) = stuff
  365.     pairs = []
  366.     for pair in pairs_list:
  367.         (fam, sub) = struct.unpack(byte_order + 'HH', struct.pack(byte_order + 'I', pair))
  368.         pairs.append((fam, sub))
  369.     
  370.     return (dict.fromkeys(pairs, id), data)
  371.  
  372.  
  373. def apply_format_rate_group_list(data, fields, byte_order, num_groups_s):
  374.     if isinstance(num_groups_s, basestring):
  375.         num_groups = fields[num_groups_s]
  376.     else:
  377.         num_groups = num_groups_s
  378.     rate_groups = { }
  379.     while data and num_groups:
  380.         (rate_group, data) = apply_format_rate_group(data, fields, byte_order)
  381.         rate_groups.update(rate_group)
  382.         num_groups -= 1
  383.     return (rate_groups, data)
  384.  
  385.  
  386. def apply_format_ssi(data, fields, byte_order):
  387.     ssi_fmt = (('name_len', 'H'), ('name', 's', 'name_len'), ('group_id', 'H'), ('item_id', 'H'), ('type_', 'H'), ('data_len', 'H'), ('tlvs', 'tlv_dict_len', 'data_len'))
  388.     (__, name, group_id, item_id, type_, __, tlvs, data) = apply_format(ssi_fmt, data, byte_order)
  389.     return (oscar.ssi.item(name, group_id, item_id, type_, tlvs), data)
  390.  
  391.  
  392. def apply_format_ssi_list(data, fields, byte_order, num_ssis_s = -1):
  393.     if isinstance(num_ssis_s, basestring):
  394.         num_ssis = fields[num_ssis_s]
  395.     else:
  396.         num_ssis = num_ssis_s
  397.     l = []
  398.     while data and num_ssis != 0:
  399.         (ssi, data) = apply_format_ssi(data, fields, byte_order)
  400.         l.append(ssi)
  401.         num_ssis -= 1
  402.     return (l, data)
  403.  
  404.  
  405. def apply_format_ssi_dict(*args):
  406.     (l, data) = apply_format_ssi_list(*args)
  407.     d = { }
  408.     for item in l:
  409.         d[(item.group_id, item.item_id)] = item
  410.     
  411.     return (d, data)
  412.  
  413.  
  414. def apply_format_lnts(data, fields, byte_order = '<'):
  415.     if byte_order != '<':
  416.         import warnings as warnings
  417.         warnings.warn('oscar.apply_format_lnts got a byte order other than little-endian')
  418.     
  419.     length = struct.unpack(byte_order + 'H', data[:2])[0]
  420.     data = data[2:]
  421.     val = data[:length]
  422.     data = data[length:]
  423.     if length:
  424.         pass
  425.     
  426.     return (val[:-1], data)
  427.  
  428.  
  429. def chat_cookie(room_name, exchange = 4):
  430.     return '!aol://2719:10-' + str(exchange) + '-' + str(room_name.replace(' ', '').lower())
  431.  
  432.